*** ../../../Gnu/gcc-1.36/cccp.c	Mon Sep 11 23:43:13 1989
--- cccp.c	Sat Sep 30 20:51:53 1989
***************
*** 23,28 ****
--- 23,30 ----
  
  typedef unsigned char U_CHAR;
  
+ #ifndef atarist
+ 
  #ifdef EMACS
  #define NO_SHORTNAMES
  #include "../src/config.h"
***************
*** 50,66 ****
  
  #ifndef VMS
  #include <sys/file.h>
! #ifndef USG
  #include <sys/time.h>		/* for __DATE__ and __TIME__ */
  #include <sys/resource.h>
  #else
  #define index strchr
  #define rindex strrchr
  #include <time.h>
  #include <fcntl.h>
! #endif /* USG */
  #endif /* not VMS */
!   
  /* VMS-specific definitions */
  #ifdef VMS
  #include <time.h>
--- 52,86 ----
  
  #ifndef VMS
  #include <sys/file.h>
! #if (!(defined(USG) || defined(atariminix)))
  #include <sys/time.h>		/* for __DATE__ and __TIME__ */
  #include <sys/resource.h>
  #else
+ #ifndef atariminix
  #define index strchr
  #define rindex strrchr
+ #endif
  #include <time.h>
  #include <fcntl.h>
! #endif /* USG or atariminix */
  #endif /* not VMS */
! 
! #else		/* atarist */
! 
! #include <ctype.h>
! #include <stdio.h>
! #include <types.h>
! #include <stat.h>
! #include <file.h>
! #include <time.h>
! #include "stddef.h"
! 
! extern long _stksize = 524288;	/* want big stack cause include files
! 				   get alloca'ed there */
! 
! #endif		/* atarist */
! 
!  
  /* VMS-specific definitions */
  #ifdef VMS
  #include <time.h>
***************
*** 249,268 ****
--- 269,327 ----
  /* #include "file" looks in source file dir, then stack. */
  /* #include <file> just looks in the stack. */
  /* -I directories are added to the end, then the defaults are added. */
+ #ifdef atarist
+ 
+ struct file_name_list include_canned_defaults[] =
+   {
+     { &include_canned_defaults[1], "\\gnu\\lib" },
+     { 0, "\\gnu\\include" }
+   };
+ 
+ struct file_name_list * include_defaults = &include_canned_defaults[0];
+ 
+ #else
+ 
  struct file_name_list include_defaults[] =
    {
  #ifndef VMS
+ #ifdef CROSSATARI
+     { 0, CROSSINC }
+ #else
+ #ifdef atariminix
+     { 0, "/usr/local/gcc-include" }
+ #else
      { &include_defaults[1], GCC_INCLUDE_DIR },
      { &include_defaults[2], "/usr/include" },
      { 0, "/usr/local/include" }
+ #endif
+ #endif
  #else
      { &include_defaults[1], "GNU_CC_INCLUDE:" },       /* GNU includes */
      { &include_defaults[2], "SYS$SYSROOT:[SYSLIB.]" }, /* VAX-11 "C" includes */
      { 0, "" },	/* This makes normal VMS filespecs work OK */
  #endif /* VMS */
    };
+ #endif /* atarist */
  
  /* These are used instead of the above, for C++.  */
+ #ifdef atarist
+ 
+ struct file_name_list include_canned_cplusplus_defaults[] =
+   {
+     { &include_canned_defaults[1], "\\gnu\\lib" },
+     { 0, "\\gnu\\include" }
+   };
+ 
+ struct file_name_list * cplusplus_include_defaults =
+ 					&include_canned_cplusplus_defaults[0];
+ 
+ #else
+ 
+ #ifdef atariminix
+ #define GPLUSPLUS_INCLUDE_DIR "/usr/local/g++-include"
+ #define GCC_INCLUDE_DIR "/usr/local/gcc-include"
+ #endif
+ 
  struct file_name_list cplusplus_include_defaults[] =
    {
  #ifndef VMS
***************
*** 270,276 ****
--- 329,339 ----
      { &cplusplus_include_defaults[1], GPLUSPLUS_INCLUDE_DIR },
      /* Use GNU CC specific header files.  */
      { &cplusplus_include_defaults[2], GCC_INCLUDE_DIR },
+ #ifdef CROSSATARI
+     { 0, CROSSINC }
+ #else
      { 0, "/usr/include" }
+ #endif
  #else
      { &cplusplus_include_defaults[1], "GNU_GXX_INCLUDE:" },
      { &cplusplus_include_defaults[2], "GNU_CC_INCLUDE:" },
***************
*** 279,284 ****
--- 342,348 ----
      { 0, "" },	/* This makes normal VMS filespecs work OK */
  #endif /* VMS */
    };
+ #endif /* atarist */
  
  struct file_name_list *include = 0;	/* First dir to search */
  	/* First dir to search for <file> */
***************
*** 507,513 ****
--- 571,631 ----
  /* Nonzero means -I- has been seen,
     so don't look for #include "foo" the source-file directory.  */
  int ignore_srcdir;
+  
+ #ifdef atarist
+ /* a little frobule to filter incoming file data */
+ int eunuchs_read(f, buf, size)
+ int f;
+ char * buf;
+ int size;
+ {
+   char local_buf[1024];
+   register int result_size;
+   register char * local_bufp, * target_bufp;
+   register int buf_size, size_read;
+ 
+   for (result_size = 0, target_bufp = buf ; size > 0 ; size -= 1024)
+ /* do a buffer */
+   	{
+ 	if (size > 1024)
+ 		buf_size = 1024;
+ 	    else
+ 	    	buf_size = size;
+ 	size_read = read(f, &local_buf, buf_size);
+ 	for (local_bufp = (char * ) &local_buf; size_read > 0 ; size_read--)
+ 		if (*local_bufp == '\r')
+ 			local_bufp++;
+ 		    else
+ 		    	{
+ 			*target_bufp++ = *local_bufp++;
+ 			result_size++;
+ 			}
+ 	}
+   return(result_size);
+ }
+ 
+ /* the following dingus is used in place of some calls to bcopy,
+    to ensure that backslashes get properly slashified when getting
+    shoved into strings.  Note that it returns the new pointer!!
+    There ought to be a better way... */
+ 
+ U_CHAR * slashifying_bcopy(from_buf, to_buf, nbytes)
+ U_CHAR * from_buf, * to_buf;
+ int nbytes;
+ {
+   for ( ; nbytes > 0 ; )
+ 	{
+ 	if(*from_buf == '\\')
+ 		*to_buf++ = '\\';
+ 	*to_buf++ = *from_buf++;
+ 	nbytes--;
+ 	}
+   return(to_buf);
+ }
+ 
+ #endif		/* atarist */
  
+ #ifndef atarist
  /* Handler for SIGPIPE.  */
  
  static void
***************
*** 515,520 ****
--- 633,639 ----
  {
    fatal ("output pipe has been closed");
  }
+ #endif
  
  int
  main (argc, argv)
***************
*** 540,545 ****
--- 659,669 ----
    /* Target-name to write with the dependency information.  */
    char *deps_target = 0;
  
+ #ifdef atarist
+ /* turn this on if you are going to set the TOS 1.4 dont clear heap flag */
+ /*  _malloczero(1); */ 	/* zero mallocs by default */
+ #endif  
+ 
  #ifdef RLIMIT_STACK
    /* Get rid of any avoidable limit on stack size.  */
    {
***************
*** 588,600 ****
--- 712,730 ----
    cplusplus = 1;
  #endif
  
+ #ifndef atarist
    signal (SIGPIPE, pipe_closed);
+ #endif  
  
  #ifndef VMS
    max_include_len
+ #ifdef atarist
+     =    sizeof ("/usr/include/CC");
+ #else
      = max (max (sizeof (GCC_INCLUDE_DIR),
  		sizeof (GPLUSPLUS_INCLUDE_DIR)),
  	   sizeof ("/usr/include/CC"));
+ #endif
  #else /* VMS */
    max_include_len
      = sizeof("SYS$SYSROOT:[SYSLIB.]");
***************
*** 604,609 ****
--- 734,759 ----
    bzero (pend_defs, argc * sizeof (char *));
    bzero (pend_undefs, argc * sizeof (char *));
  
+ #ifdef atarist
+ /* see if we have an indication of where the GNU library directory is */
+   {
+     char * gnulib = (char * ) getenv("GNUINC");
+     struct file_name_list * gnulib_dir;
+ 
+     if(!gnulib) gnulib = (char *) getenv("GNULIB"); /* try GNULIB */
+     if (gnulib)
+ 	{
+ 	gnulib_dir = (struct file_name_list * ) 
+ 		xmalloc(sizeof(struct file_name_list));
+ 	gnulib_dir->fname = xmalloc(strlen(gnulib) + 1);
+ 	strcpy(gnulib_dir->fname, gnulib);
+ /* cons it onto the front of the defaults. */
+ 	gnulib_dir->next = include_defaults;
+ 	include_defaults = gnulib_dir;
+ 	}
+   }
+ #endif
+ 
    /* Process switches and find input file name.  */
  
    for (i = 1; i < argc; i++) {
***************
*** 968,974 ****
--- 1118,1128 ----
      fp->buf = (U_CHAR *) xmalloc (bsize + 2);
      bufp = fp->buf;
      for (;;) {
+ #ifdef atarist
+       cnt = eunuchs_read (f, bufp, bsize - size);
+ #else
        cnt = read (f, bufp, bsize - size);
+ #endif
        if (cnt < 0) goto perror;	/* error! */
        if (cnt == 0) break;	/* End of file */
        size += cnt;
***************
*** 988,994 ****
--- 1142,1152 ----
      fp->buf = (U_CHAR *) xmalloc (st_size + 2);
  
      while (st_size > 0) {
+ #ifdef atarist
+       i = eunuchs_read (f, fp->buf + fp->length, st_size);
+ #else
        i = read (f, fp->buf + fp->length, st_size);
+ #endif
        if (i <= 0) {
          if (i == 0) break;
  	goto perror;
***************
*** 1048,1053 ****
--- 1206,1214 ----
    if (ferror (stdout))
      fatal ("I/O error on output");
  
+ #ifdef atarist
+   close(fileno(stdout));		/* this shouldn't be necessary */
+ #endif
    if (errors)
      exit (FATAL_EXIT_CODE);
    exit (SUCCESS_EXIT_CODE);
***************
*** 2333,2340 ****
--- 2494,2510 ----
  
        if (string)
  	{
+ #ifndef atarist
  	  buf = (char *) alloca (3 + strlen (string));
  	  sprintf (buf, "\"%s\"", string);
+ #else
+     	  buf = (char *) alloca (16 + strlen (string));
+           {
+ 	      char *tbuf = (char *) alloca (16 + strlen (string));
+ 	      (void) slashifying_bcopy(string, tbuf, strlen(string)+1);
+ 	      sprintf (buf, "\"%s\"", tbuf);
+           }
+ #endif /* atarist */
  	}
        else
  	buf = "\"\"";
***************
*** 2485,2490 ****
--- 2655,2664 ----
  	       and put it in front of the search list.  */
  	    dsp[0].next = stackp;
  	    stackp = dsp;
+ #ifdef atarist
+ 	      if((ep = rindex (nam, '\\')) == NULL)
+ 		  ep = rindex(nam, '/');	/* allow both */
+ #else
  #ifndef VMS
  	    ep = rindex (nam, '/');
  #else				/* VMS */
***************
*** 2493,2498 ****
--- 2667,2673 ----
  	    if (ep == NULL) ep = rindex (nam, ':');
  	    if (ep != NULL) ep++;
  #endif				/* VMS */
+ #endif /* atarist */
  	    if (ep != NULL) {
  	      n = ep - nam;
  	      dsp[0].fname = (char *) alloca (n + 1);
***************
*** 2543,2549 ****
--- 2718,2728 ----
  
    /* If specified file name is absolute, just open it.  */
  
+ #ifdef atarist
+   if ((*fbeg == '\\') || (*fbeg == '/')) {
+ #else
    if (*fbeg == '/') {
+ #endif
      strncpy (fname, fbeg, flen);
      fname[flen] = 0;
      f = open (fname, O_RDONLY, 0666);
***************
*** 2554,2560 ****
--- 2733,2743 ----
      for (; stackp; stackp = stackp->next) {
        if (stackp->fname) {
  	strcpy (fname, stackp->fname);
+ #ifdef atarist
+ 	strcat (fname, "\\");
+ #else
  	strcat (fname, "/");
+ #endif
  	fname[strlen (fname) + flen] = 0;
        } else {
  	fname[0] = 0;
***************
*** 2674,2680 ****
      /* Read the file contents, knowing that st_size is an upper bound
         on the number of bytes we can read.  */
      while (st_size > 0) {
!       i = read (f, fp->buf + fp->length, st_size);
        if (i <= 0) {
  	if (i == 0) break;
  	goto nope;
--- 2857,2867 ----
      /* Read the file contents, knowing that st_size is an upper bound
         on the number of bytes we can read.  */
      while (st_size > 0) {
! #ifdef atarist
!     i = eunuchs_read (f, fp->buf + fp->length, st_size);
! #else
!     i = read (f, fp->buf + fp->length, st_size);
! #endif
        if (i <= 0) {
  	if (i == 0) break;
  	goto nope;
***************
*** 2697,2703 ****
--- 2884,2894 ----
      bufp = basep;
  
      for (;;) {
+ #ifdef atarist
+     i = eunuchs_read (f, bufp, bsize - st_size);
+ #else
        i = read (f, bufp, bsize - st_size);
+ #endif
        if (i < 0)
  	goto nope;      /* error! */
        if (i == 0)
***************
*** 4067,4074 ****
--- 4258,4269 ----
    check_expand (op, len + 1);
    if (op->bufp > op->buf && op->bufp[-1] != '\n')
      *op->bufp++ = '\n';
+ #ifdef atarist
+   op->bufp = slashifying_bcopy (line_cmd_buf, op->bufp, len);
+ #else
    bcopy (line_cmd_buf, op->bufp, len);
    op->bufp += len;
+ #endif
    op->lineno = ip->lineno;
  }
  
***************
*** 4725,4731 ****
--- 4920,4930 ----
    if (ip != NULL)
      fprintf (stderr, "%s:%d: ", ip->fname, ip->lineno);
  
+ #ifdef atarist
+   if ((errno > sys_nerr) && (errno < 0))
+ #else
    if (errno < sys_nerr)
+ #endif
      fprintf (stderr, "%s: %s\n", name, sys_errlist[errno]);
    else
      fprintf (stderr, "%s: undocumented I/O error\n", name);
***************
*** 5251,5256 ****
--- 5450,5456 ----
    deps_buffer[deps_size] = 0;
  }
  
+ #if (!(defined(atarist) || defined(atariminix) || defined(CROSSATARI)))
  #ifndef BSD
  #ifndef BSTRING
  
***************
*** 5318,5324 ****
  }
  #endif /* not BSTRING */
  #endif /* not BSD */
! 
  
  void
  fatal (str, arg)
--- 5518,5524 ----
  }
  #endif /* not BSTRING */
  #endif /* not BSD */
! #endif /* not ATARI */
  
  void
  fatal (str, arg)
***************
*** 5347,5353 ****
--- 5547,5557 ----
    extern char *sys_errlist[];
  
    fprintf (stderr, "%s: ", progname);
+ #ifdef atarist
+   if ((errno > sys_nerr) && (errno < 0))
+ #else
    if (errno < sys_nerr)
+ #endif
      fprintf (stderr, "%s: %s\n", name, sys_errlist[errno]);
    else
      fprintf (stderr, "%s: undocumented I/O error\n", name);
*** ../../../Gnu/gcc-1.36/combine.c	Fri Sep 15 00:40:17 1989
--- combine.c	Wed Sep 27 12:28:46 1989
***************
*** 814,820 ****
--- 814,824 ----
    register char *fmt;
    register int len, i;
    register enum rtx_code code;
+ #if (defined(atarist) || defined(atariminix))
+   short was_replaced[2];	/* 'char' confuses GAS 1.14... */
+ #else
    char was_replaced[2];
+ #endif
  
  #define SUBST(INTO, NEWVAL)  \
   do { if (undobuf.num_undo < MAX_UNDO)					\
*** ../../../Gnu/gcc-1.36/gcc.c	Sun Sep 17 16:51:58 1989
--- gcc.c	Sat Sep 30 20:51:53 1989
***************
*** 117,122 ****
--- 117,131 ----
  
  */
  
+ #ifdef CROSSATARI
+ #ifdef atarist
+ #undef atarist
+ #endif
+ #ifdef atariminix
+ #undef atariminix
+ #endif
+ #endif
+   
  #include <stdio.h>
  #include <sys/types.h>
  #include <signal.h>
***************
*** 126,138 ****
  #include "obstack.h"
  #include "gvarargs.h"
  
! #ifdef USG
  #define R_OK 4
  #define W_OK 2
  #define X_OK 1
  #define vfork fork
  #endif /* USG */
  
  #define obstack_chunk_alloc xmalloc
  #define obstack_chunk_free free
  extern int xmalloc ();
--- 135,154 ----
  #include "obstack.h"
  #include "gvarargs.h"
  
! #if (defined(USG) || defined(atariminix))
  #define R_OK 4
  #define W_OK 2
  #define X_OK 1
  #define vfork fork
  #endif /* USG */
  
+ #ifdef atarist
+ #include <osbind.h>
+ #include <ctype.h>
+ long _stksize = 8192;
+ extern char *getenv();
+ #endif
+ 
  #define obstack_chunk_alloc xmalloc
  #define obstack_chunk_free free
  extern int xmalloc ();
***************
*** 232,239 ****
  {
    {".c",
     "cpp %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{i*} %{trigraphs} -undef \
!         -D__GNUC__ %{ansi:-trigraphs -$ -D__STRICT_ANSI__} %{!ansi:%p} %P\
!         %c %{O:-D__OPTIMIZE__} %{traditional} %{pedantic}\
  	%{Wcomment*} %{Wtrigraphs} %{Wall} %C\
          %i %{!M*:%{!E:%{!pipe:%g.cpp}}}%{E:%{o*}}%{M*:%{o*}} |\n\
      %{!M*:%{!E:cc1 %{!pipe:%g.cpp} %1 \
--- 248,256 ----
  {
    {".c",
     "cpp %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{i*} %{trigraphs} -undef \
!         -D__GNUC__ %{ansi:-trigraphs -$ -D__STRICT_ANSI__} %{!ansi:%p}\
!         %c %{O:-D__OPTIMIZE__} %{mshort:-D__MSHORT__} %{traditional}\
!         %{pedantic}\
  	%{Wcomment*} %{Wtrigraphs} %{Wall} %C\
          %i %{!M*:%{!E:%{!pipe:%g.cpp}}}%{E:%{o*}}%{M*:%{o*}} |\n\
      %{!M*:%{!E:cc1 %{!pipe:%g.cpp} %1 \
***************
*** 247,254 ****
                        %{!pipe:%g.s}\n }}}"},
    {".cc",
     "cpp -+ %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{i*} \
!         -undef -D__GNUC__ %p %P\
!         %c %{O:-D__OPTIMIZE__} %{traditional} %{pedantic}\
  	%{Wcomment*} %{Wtrigraphs} %{Wall} %C\
          %i %{!M*:%{!E:%{!pipe:%g.cpp}}}%{E:%{o*}}%{M*:%{o*}} |\n\
      %{!M*:%{!E:cc1plus %{!pipe:%g.cpp} %1\
--- 264,272 ----
                        %{!pipe:%g.s}\n }}}"},
    {".cc",
     "cpp -+ %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{i*} \
!         -undef -D__GNUC__ %p\
!         %c %{O:-D__OPTIMIZE__} %{mshort:-D__MSHORT__} %{traditional}\
!         %{pedantic}\
  	%{Wcomment*} %{Wtrigraphs} %{Wall} %C\
          %i %{!M*:%{!E:%{!pipe:%g.cpp}}}%{E:%{o*}}%{M*:%{o*}} |\n\
      %{!M*:%{!E:cc1plus %{!pipe:%g.cpp} %1\
***************
*** 272,279 ****
              %{c:%{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%b.o} %i\n }"},
    {".S",
     "cpp %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{trigraphs} \
!         -undef -D__GNUC__ -$ %p %P\
!         %c %{O:-D__OPTIMIZE__} %{traditional} %{pedantic}\
  	%{Wcomment*} %{Wtrigraphs} %{Wall} %C\
          %i %{!M*:%{!E:%{!pipe:%g.s}}}%{E:%{o*}}%{M*:%{o*}} |\n\
      %{!M*:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a \
--- 290,298 ----
              %{c:%{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%b.o} %i\n }"},
    {".S",
     "cpp %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{trigraphs} \
!         -undef -D__GNUC__ -$ %p\
!         %c %{O:-D__OPTIMIZE__} %{mshort:-D__MSHORT__} %{traditional}\
!         %{pedantic}\
  	%{Wcomment*} %{Wtrigraphs} %{Wall} %C\
          %i %{!M*:%{!E:%{!pipe:%g.s}}}%{E:%{o*}}%{M*:%{o*}} |\n\
      %{!M*:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a \
***************
*** 284,293 ****
--- 303,324 ----
  };
  
  /* Here is the spec for running the linker, after compiling all files.  */
+ 
+ #if (defined(CROSSATARI) || defined(atarist) || defined(atariminix))
+  
+  char *link_spec = "%{!c:%{!M*:%{!E:%{!S:ld %{o*} %l\
+  %{A} %{d} %{e*} %{N} %{n} %{r} %{s} %{S} %{T*} %{t} %{u*} %{X} %{x} %{z}\
+  %{y*} %{!nostdlib:%S} \
+  %{L*} %o %{!nostdlib:%s %L}\n }}}}";
+ 
+ #else
+ 
  char *link_spec = "%{!c:%{!M*:%{!E:%{!S:ld %{o*} %l\
   %{A} %{d} %{e*} %{N} %{n} %{r} %{s} %{S} %{T*} %{t} %{u*} %{X} %{x} %{z}\
   %{y*} %{!A:%{!nostdlib:%S}} \
   %{L*} %o %{!nostdlib:gnulib%s %{g:-lg} %L}\n }}}}";
+ 
+ #endif /* not atari */
  
  /* Accumulate a command (program name and args), and run it.  */
  
***************
*** 327,348 ****
  
  /* Suffix to attach to directories searched for commands.  */
  
! char *machine_suffix = 0;
  
  /* Default prefixes to attach to command names.  */
  
  #ifndef STANDARD_EXEC_PREFIX
! #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-"
  #endif /* !defined STANDARD_EXEC_PREFIX */
  
  char *standard_exec_prefix = STANDARD_EXEC_PREFIX;
  char *standard_exec_prefix_1 = "/usr/lib/gcc-";
  
! #ifndef STANDARD_STARTFILE_PREFIX
! #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
! #endif /* !defined STANDARD_STARTFILE_PREFIX */
  
- char *standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
  char *standard_startfile_prefix_1 = "/lib/";
  char *standard_startfile_prefix_2 = "/usr/lib/";
  
--- 358,403 ----
  
  /* Suffix to attach to directories searched for commands.  */
  
! #ifndef atarist
!   char *machine_suffix = 0;
! #else
!   char *machine_suffix = ".ttp";
! #endif
  
  /* Default prefixes to attach to command names.  */
  
  #ifndef STANDARD_EXEC_PREFIX
! #  ifdef CROSSATARI
! #    ifdef MINIX
! #      define STANDARD_EXEC_PREFIX "/dsrg/bammi/cross-minix/lib/gcc-"
! #    else
! #      define STANDARD_EXEC_PREFIX "/dsrg/bammi/cross-gcc/lib/gcc-"
! #    endif /* MINIX */
! #  else /* not cross compiler */
! #    define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-"
! #  endif /* CROSSATARI */
  #endif /* !defined STANDARD_EXEC_PREFIX */
  
  char *standard_exec_prefix = STANDARD_EXEC_PREFIX;
  char *standard_exec_prefix_1 = "/usr/lib/gcc-";
  
! #ifdef CROSSATARI
! #  ifdef MINIX
!     char *standard_startfile_prefix = "/dsrg/bammi/cross-minix/lib/";
! #  else
!     char *standard_startfile_prefix = "/dsrg/bammi/cross-gcc/lib/";
! #  endif
! #else
! #  ifdef atariminix
!     char *standard_startfile_prefix = "/usr/local/lib/";
! #  else
! #    ifndef STANDARD_STARTFILE_PREFIX
! #      define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
! #    endif /* !defined STANDARD_STARTFILE_PREFIX */
!      char *standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
! #  endif
! #endif
  
  char *standard_startfile_prefix_1 = "/lib/";
  char *standard_startfile_prefix_2 = "/usr/lib/";
  
***************
*** 520,527 ****
  choose_temp_base ()
  {
    extern char *getenv ();
-   char *base = getenv ("TMPDIR");
    int len;
  
    if (base == (char *)0)
      {
--- 575,588 ----
  choose_temp_base ()
  {
    extern char *getenv ();
    int len;
+ #if (!(defined(atarist) || defined(atariminix)))
+   char *base = getenv ("TMPDIR");
+ #else
+   char *base = getenv ("TEMP");
+   if(base == (char *)0)
+       base = getenv("TMPDIR");
+ #endif
  
    if (base == (char *)0)
      {
***************
*** 579,586 ****
        if (machine_suffix)
  	{
  	  strcpy (temp, user_exec_prefix);
- 	  strcat (temp, machine_suffix);
  	  strcat (temp, prog);
  	  win = (access (temp, X_OK) == 0);
  	}
        if (!win)
--- 640,647 ----
        if (machine_suffix)
  	{
  	  strcpy (temp, user_exec_prefix);
  	  strcat (temp, prog);
+ 	  strcat (temp, machine_suffix);
  	  win = (access (temp, X_OK) == 0);
  	}
        if (!win)
***************
*** 596,603 ****
        if (machine_suffix)
  	{
  	  strcpy (temp, env_exec_prefix);
- 	  strcat (temp, machine_suffix);
  	  strcat (temp, prog);
  	  win = (access (temp, X_OK) == 0);
  	}
        if (!win)
--- 657,664 ----
        if (machine_suffix)
  	{
  	  strcpy (temp, env_exec_prefix);
  	  strcat (temp, prog);
+ 	  strcat (temp, machine_suffix);
  	  win = (access (temp, X_OK) == 0);
  	}
        if (!win)
***************
*** 613,620 ****
        if (machine_suffix)
  	{
  	  strcpy (temp, standard_exec_prefix);
- 	  strcat (temp, machine_suffix);
  	  strcat (temp, prog);
  	  win = (access (temp, X_OK) == 0);
  	}
        if (!win)
--- 674,681 ----
        if (machine_suffix)
  	{
  	  strcpy (temp, standard_exec_prefix);
  	  strcat (temp, prog);
+ 	  strcat (temp, machine_suffix);
  	  win = (access (temp, X_OK) == 0);
  	}
        if (!win)
***************
*** 630,637 ****
        if (machine_suffix)
  	{
  	  strcpy (temp, standard_exec_prefix_1);
- 	  strcat (temp, machine_suffix);
  	  strcat (temp, prog);
  	  win = (access (temp, X_OK) == 0);
  	}
        if (!win)
--- 691,698 ----
        if (machine_suffix)
  	{
  	  strcpy (temp, standard_exec_prefix_1);
  	  strcat (temp, prog);
+ 	  strcat (temp, machine_suffix);
  	  win = (access (temp, X_OK) == 0);
  	}
        if (!win)
***************
*** 671,676 ****
--- 732,738 ----
     NOT_LAST is nonzero if this is not the last subcommand
     (i.e. its output should be piped to the next one.)  */
  
+ #ifndef atarist
  static int
  pexecute (func, program, argv, not_last)
       char *program;
***************
*** 741,746 ****
--- 803,809 ----
        return pid;
      }
  }
+ #endif /* atarist */
  
  /* Execute the command specified by the arguments on the current line of spec.
     When using pipes, this includes several piped-together commands
***************
*** 758,773 ****
      {
        char *prog;		/* program name.  */
        char **argv;		/* vector of args.  */
        int pid;			/* pid of process for this command.  */
      };
  
    struct command *commands;	/* each command buffer with above info.  */
  
    /* Count # of piped commands.  */
    for (n_commands = 1, i = 0; i < argbuf_index; i++)
      if (strcmp (argbuf[i], "|") == 0)
!       n_commands++;
! 
    /* Get storage for each command.  */
    commands
      = (struct command *) alloca (n_commands * sizeof (struct command));
--- 821,842 ----
      {
        char *prog;		/* program name.  */
        char **argv;		/* vector of args.  */
+ #ifndef atarist
        int pid;			/* pid of process for this command.  */
+ #endif
      };
  
    struct command *commands;	/* each command buffer with above info.  */
  
+ #ifndef atarist
    /* Count # of piped commands.  */
    for (n_commands = 1, i = 0; i < argbuf_index; i++)
      if (strcmp (argbuf[i], "|") == 0)
!      n_commands++;
! #else
!   n_commands = 1;
! #endif
!   
    /* Get storage for each command.  */
    commands
      = (struct command *) alloca (n_commands * sizeof (struct command));
***************
*** 782,787 ****
--- 851,857 ----
    if (string)
      commands[0].argv[0] = string;
  
+ #ifndef atarist
    for (n_commands = 1, i = 0; i < argbuf_index; i++)
      if (strcmp (argbuf[i], "|") == 0)
        {				/* each command.  */
***************
*** 793,799 ****
  	  commands[n_commands].argv[0] = string;
  	n_commands++;
        }
! 
    argbuf[argbuf_index] = 0;
  
    /* If -v, print what we are about to do, and maybe query.  */
--- 863,872 ----
  	  commands[n_commands].argv[0] = string;
  	n_commands++;
        }
! #else
!   n_commands = 1;
! #endif
!   
    argbuf[argbuf_index] = 0;
  
    /* If -v, print what we are about to do, and maybe query.  */
***************
*** 808,818 ****
  	  for (j = commands[i].argv; *j; j++)
  	    fprintf (stderr, " %s", *j);
  
  	  /* Print a pipe symbol after all but the last command.  */
  	  if (i + 1 != n_commands)
  	    fprintf (stderr, " |");
  	  fprintf (stderr, "\n");
! 	}
        fflush (stderr);
  #ifdef DEBUG
        fprintf (stderr, "\nGo ahead? (y or n) ");
--- 881,893 ----
  	  for (j = commands[i].argv; *j; j++)
  	    fprintf (stderr, " %s", *j);
  
+ #ifndef atarist
  	  /* Print a pipe symbol after all but the last command.  */
  	  if (i + 1 != n_commands)
  	    fprintf (stderr, " |");
+ #endif
  	  fprintf (stderr, "\n");
!       }
        fflush (stderr);
  #ifdef DEBUG
        fprintf (stderr, "\nGo ahead? (y or n) ");
***************
*** 825,842 ****
--- 900,926 ----
  #endif /* DEBUG */
      }
  
+ #ifndef atarist
    /* Run each piped subprocess.  */
  
    last_pipe_input = STDIN_FILE_NO;
    for (i = 0; i < n_commands; i++)
      {
+ #ifndef atariminix
        extern int execv(), execvp();
        char *string = commands[i].argv[0];
  
        commands[i].pid = pexecute ((string != commands[i].prog ? execv : execvp),
  				  string, commands[i].argv,
  				  i + 1 < n_commands);
+ #else
+       extern int execv();
+       char *string = commands[i].argv[0];
  
+       commands[i].pid = pexecute (execv,
+ 				  string, commands[i].argv,
+ 				  i + 1 < n_commands);
+ #endif
        if (string != commands[i].prog)
  	free (string);
      }
***************
*** 875,881 ****
--- 959,982 ----
        }
      return ret_code;
    }
+ #else  /* atarist */
+  {
+      register int iii;
+      char **j;
+ 
+      execution_count++;
+      for (i = 0; i < n_commands ; i++)
+      {
+ 	 j = commands[i].argv;
+          iii = spawnve(0, j[0], j, NULL);
+ 	 if(iii != 0)
+ 	     return -1;
+      }
+      return 0;
+  }
+ #endif /* atarist */  
  }
+ 
  
  /* Find all the switches given to us
     and make a vector describing them.
***************
*** 1032,1037 ****
--- 1133,1148 ----
     search dirs for it.  */
  int this_is_library_file;
  
+ #ifdef atarist
+ /* I don't know why this is necessary.  Recursive calls to do_spec_1
+    end up ignoring the error code from calls to execute().  That causes
+    do_spec to get a 0 return value, and do_spec_1("\n"), which causes the
+    command to get executed again.
+ */
+ int execute_return_error = 0;
+ #endif
+ 
+ 
  /* Process the spec SPEC and run the commands specified therein.
     Returns 0 if the spec is successfully processed; -1 if failed.  */
  
***************
*** 1051,1060 ****
--- 1162,1180 ----
  
    /* Force out any unfinished command.
       If -pipe, this forces out the last command if it ended in `|'.  */
+ #ifdef atarist
+   if (!value && execute_return_error)
+ 	{
+ 	value = execute_return_error;
+ 	execute_return_error = 0;
+ 	}
+ #endif
    if (value == 0)
      {
+ #ifndef atarist
        if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
  	argbuf_index--;
+ #endif
  
        if (argbuf_index > 0)
  	value = execute ();
***************
*** 1083,1094 ****
--- 1203,1248 ----
    register char *p = spec;
    register int c;
    char *string;
+   extern char *find_file();	/* ++jrb */
  
    while (c = *p++)
      /* If substituting a switch, treat all chars like letters.
         Otherwise, NL, SPC, TAB and % are special.  */
      switch (inswitch ? 'a' : c)
        {
+ #ifdef atarist
+ /* this stuff added by jrd.  if see '$', expect name of env var, delimited
+    by '$'.  Find it's value, and subst it in.
+ 
+    modified by ERS to only collect things that look like names; this
+    saves e.g. the -$ arg. to cpp from getting munged */
+ 
+       case '$':
+       {
+ 	char varname[32];		/* should be enough */
+ 	char * value;			/* deciphered value string */
+ 	int i;
+ 
+ 	for (i = 0 ; ((c = *p) != '$') && isalnum(c) && i < 31 ; i++, p++)
+ 		varname[i] = c;
+ 	varname[i] = '\0';
+ 	if (strlen(varname) > 0) /* ++jrb fix */
+ 	{
+              	++p;    /* skip trailing '$' */
+ 		value = (char * )getenv(varname); /* ++jrb fix */
+ 		if (value)
+ 			do_spec_1(value, 0);
+ 		    else
+ 			do_spec_1(".", 0);	/* a compleat kludge... */
+ 	}
+         else
+         {
+              obstack_1grow(&obstack, '$');
+              arg_going = 1;
+         }
+       }
+      break;
+ #endif /* atarist */
        case '\n':
  	/* End of line: finish any pending argument,
  	   then run the pending command if one has been started.  */
***************
*** 1126,1131 ****
--- 1280,1289 ----
  	if (argbuf_index > 0)
  	  {
  	    int value = execute ();
+ #ifdef atarist
+ 		if (!execute_return_error)
+ 			execute_return_error = value;
+ #endif
  	    if (value)
  	      return value;
  	  }
***************
*** 1312,1317 ****
--- 1470,1479 ----
  	    break;
  
  	  default:
+ #ifdef atarist
+ 	    fprintf(stderr, "Bogus char '%c' found at pos %d of spec '%s'\n",
+ 		c, (p - spec - 1), spec);
+ #endif
  	    abort ();
  	  }
  	break;
***************
*** 1342,1355 ****
         This is used in %{|!pipe:...}.  */
      pipe = 1, ++p;
  
!   if (*p == '!')
      /* A `!' after the open-brace negates the condition:
         succeed if the specified switch is not present.  */
      negate = 1, ++p;
  
!   filter = p;
!   while (*p != ':' && *p != '}') p++;
!   if (*p != '}')
      {
        register int count = 1;
        q = p + 1;
--- 1504,1517 ----
         This is used in %{|!pipe:...}.  */
      pipe = 1, ++p;
  
!    if (*p == '!')
      /* A `!' after the open-brace negates the condition:
         succeed if the specified switch is not present.  */
      negate = 1, ++p;
  
!     filter = p;
!     while (*p != ':' && *p != '}') p++;
!     if (*p != '}')
      {
        register int count = 1;
        q = p + 1;
***************
*** 1425,1431 ****
  		return 0;
  	    }
  	}
!       else if (pipe)
  	{
  	  /* Here if a %{|...} conditional fails: output a minus sign,
  	     which means "standard output" or "standard input".  */
--- 1587,1593 ----
  		return 0;
  	    }
  	}
!         else if (pipe)
  	{
  	  /* Here if a %{|...} conditional fails: output a minus sign,
  	     which means "standard output" or "standard input".  */
***************
*** 1496,1503 ****
        if (machine_suffix)
  	{
  	  strcpy (temp, user_exec_prefix);
- 	  strcat (temp, machine_suffix);
  	  strcat (temp, name);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
--- 1658,1665 ----
        if (machine_suffix)
  	{
  	  strcpy (temp, user_exec_prefix);
  	  strcat (temp, name);
+ 	  strcat (temp, machine_suffix);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
***************
*** 1513,1520 ****
        if (machine_suffix)
  	{
  	  strcpy (temp, env_exec_prefix);
- 	  strcat (temp, machine_suffix);
  	  strcat (temp, name);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
--- 1675,1682 ----
        if (machine_suffix)
  	{
  	  strcpy (temp, env_exec_prefix);
  	  strcat (temp, name);
+ 	  strcat (temp, machine_suffix);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
***************
*** 1530,1537 ****
        if (machine_suffix)
  	{
  	  strcpy (temp, standard_exec_prefix);
- 	  strcat (temp, machine_suffix);
  	  strcat (temp, name);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
--- 1692,1699 ----
        if (machine_suffix)
  	{
  	  strcpy (temp, standard_exec_prefix);
  	  strcat (temp, name);
+ 	  strcat (temp, machine_suffix);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
***************
*** 1547,1554 ****
        if (machine_suffix)
  	{
  	  strcpy (temp, standard_exec_prefix_1);
- 	  strcat (temp, machine_suffix);
  	  strcat (temp, name);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
--- 1709,1716 ----
        if (machine_suffix)
  	{
  	  strcpy (temp, standard_exec_prefix_1);
  	  strcat (temp, name);
+ 	  strcat (temp, machine_suffix);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
***************
*** 1564,1571 ****
        if (machine_suffix)
  	{
  	  strcpy (temp, standard_startfile_prefix);
- 	  strcat (temp, machine_suffix);
  	  strcat (temp, name);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
--- 1726,1733 ----
        if (machine_suffix)
  	{
  	  strcpy (temp, standard_startfile_prefix);
  	  strcat (temp, name);
+ 	  strcat (temp, machine_suffix);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
***************
*** 1581,1588 ****
        if (machine_suffix)
  	{
  	  strcpy (temp, standard_startfile_prefix_1);
- 	  strcat (temp, machine_suffix);
  	  strcat (temp, name);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
--- 1743,1750 ----
        if (machine_suffix)
  	{
  	  strcpy (temp, standard_startfile_prefix_1);
  	  strcat (temp, name);
+ 	  strcat (temp, machine_suffix);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
***************
*** 1598,1605 ****
        if (machine_suffix)
  	{
  	  strcpy (temp, standard_startfile_prefix_2);
- 	  strcat (temp, machine_suffix);
  	  strcat (temp, name);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
--- 1760,1767 ----
        if (machine_suffix)
  	{
  	  strcpy (temp, standard_startfile_prefix_2);
  	  strcat (temp, name);
+ 	  strcat (temp, machine_suffix);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
***************
*** 1615,1622 ****
        if (machine_suffix)
  	{
  	  strcpy (temp, "./");
- 	  strcat (temp, machine_suffix);
  	  strcat (temp, name);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
--- 1777,1784 ----
        if (machine_suffix)
  	{
  	  strcpy (temp, "./");
  	  strcat (temp, name);
+ 	  strcat (temp, machine_suffix);
  	  win = (access (temp, R_OK) == 0);
  	}
        if (!win)
***************
*** 1634,1639 ****
--- 1796,1802 ----
  
  /* On fatal signals, delete all the temporary files.  */
  
+ #ifndef atarist
  void
  fatal_error (signum)
       int signum;
***************
*** 1645,1650 ****
--- 1808,1814 ----
       so its normal effect occurs.  */
    kill (getpid (), signum);
  }
+ #endif /* atarist */
  
  int
  main (argc, argv)
***************
*** 1657,1670 ****
--- 1821,1842 ----
    int linker_was_run = 0;
    char *explicit_link_files;
  
+ #ifdef atarist
+ /* turn this on if you are going to set the TOS 1.4 dont clear heap flag */
+ /*  _malloczero(1); */ 	/* zero mallocs by default */
+   programname = "gcc";
+ #else  
    programname = argv[0];
+ #endif
  
+ #ifndef atarist
    if (signal (SIGINT, SIG_IGN) != SIG_IGN)
      signal (SIGINT, fatal_error);
    if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
      signal (SIGHUP, fatal_error);
    if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
      signal (SIGTERM, fatal_error);
+ #endif
  
    argbuf_length = 10;
    argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
***************
*** 1678,1683 ****
--- 1850,1865 ----
  
    process_command (argc, argv);
  
+ #ifdef atarist
+ /* if no default dir specified for executables, look for an env var
+    called 'GCCEXEC' and use that */
+ 
+   if (!user_exec_prefix)
+   	{
+ 	user_exec_prefix = getenv("GCCEXEC");
+ 	}
+ #endif /* atarist */
+ 
    if (vflag)
      {
        extern char *version_string;
***************
*** 1730,1736 ****
--- 1912,1923 ----
  
  	      input_basename = input_filename;
  	      for (p = input_filename; *p; p++)
+ #ifdef atarist
+ 		if (((*p == '/') || (*p == '\\')) && (*(p-1) != ':'))
+ 		    /* allow both '\' and '/' with  our new lib */
+ #else
  		if (*p == '/')
+ #endif
  		  input_basename = p + 1;
  	      basename_length = (input_filename_length - strlen (cp->suffix)
  				 - (input_basename - input_filename));
***************
*** 1852,1858 ****
--- 2039,2049 ----
    extern char *sys_errlist[];
    char *s;
  
+ #ifdef atarist
+   if ((errno > sys_nerr) && (errno < 0))
+ #else
    if (errno < sys_nerr)
+ #endif
      s = concat ("%s: ", sys_errlist[errno], "");
    else
      s = "cannot open %s";
***************
*** 1866,1872 ****
--- 2057,2067 ----
    extern char *sys_errlist[];
    char *s;
  
+ #ifdef atarist
+   if ((errno > sys_nerr) && (errno < 0))
+ #else
    if (errno < sys_nerr)
+ #endif
      s = concat ("%s: ", sys_errlist[errno], "");
    else
      s = "cannot open %s";
***************
*** 1880,1886 ****
--- 2075,2085 ----
    extern char *sys_errlist[];
    char *s;
  
+ #ifdef atarist
+   if ((errno > sys_nerr) && (errno < 0))
+ #else
    if (errno < sys_nerr)
+ #endif
      s = concat ("installation problem, cannot exec %s: ",
  		sys_errlist[errno], "");
    else
*** ../../../Gnu/gcc-1.36/toplev.c	Thu Sep  7 23:21:14 1989
--- toplev.c	Sat Sep 30 20:51:54 1989
***************
*** 40,49 ****
  #include <time.h>   /* Correct for hpux at least.  Is it good on other USG?  */
  #else
  #ifndef VMS
  #include <sys/time.h>
  #include <sys/resource.h>
  #endif
- #endif
  
  #include "input.h"
  #include "tree.h"
--- 40,57 ----
  #include <time.h>   /* Correct for hpux at least.  Is it good on other USG?  */
  #else
  #ifndef VMS
+ #if (!(defined(atarist) || defined(atariminix)))
  #include <sys/time.h>
  #include <sys/resource.h>
+ #endif /* !(atarist || atariminix) */
+ #endif /* !VMS */
+ #endif /* USG */
+ 
+ #ifdef atariminix
+ #include <sys/times.h>
+ /* #include <minix/const.h>, avoid dragging this in */
+ #define HZ 60	/* this is the only thing needed from minix/const.h */
  #endif
  
  #include "input.h"
  #include "tree.h"
***************
*** 51,56 ****
--- 59,69 ----
  #include "rtl.h"
  #include "flags.h"
  
+ #ifdef atarist
+   extern long _stksize = 128L * 1024L;		/* for 1M ST's */
+   /* extern long _stksize = 500000; */		/* enough to compile -O gas */
+ #endif /* atarist */
+ 
  extern int yydebug;
  
  extern FILE *finput;
***************
*** 375,381 ****
  int
  gettime ()
  {
! #ifdef USG
    struct tms tms;
  #else
  #ifndef VMS
--- 388,397 ----
  int
  gettime ()
  {
! #ifdef atarist
!   long now;
! #else
! #if (defined(USG) || defined(atariminix))
    struct tms tms;
  #else
  #ifndef VMS
***************
*** 390,400 ****
      } vms_times;
  #endif
  #endif
  
    if (quiet_flag)
      return 0;
  
! #ifdef USG
    times (&tms);
    return (tms.tms_utime + tms.tms_stime) * (1000000 / HZ);
  #else
--- 406,420 ----
      } vms_times;
  #endif
  #endif
+ #endif
  
    if (quiet_flag)
      return 0;
  
! #ifdef atarist
!   return(time(NULL) * 1000000);
! #else
! #if (defined(USG) || defined(atariminix))
    times (&tms);
    return (tms.tms_utime + tms.tms_stime) * (1000000 / HZ);
  #else
***************
*** 407,412 ****
--- 427,433 ----
    return (vms_times.proc_user_time + vms_times.proc_system_time) * 10000;
  #endif
  #endif
+ #endif		/* atarist */
  }
  
  #define TIMEVAR(VAR, BODY)    \
***************
*** 850,855 ****
--- 871,877 ----
    longjmp (float_handler, 1);
  }
  
+ #ifndef atarist
  /* Handler for SIGPIPE.  */
  
  static void
***************
*** 857,862 ****
--- 879,885 ----
  {
    fatal ("output pipe has been closed");
  }
+ #endif
  
  /* Compile an entire file of output from cpp, named NAME.
     Write a file of assembly output and various debugging dumps.  */
***************
*** 1735,1747 ****
    char *filename = 0;
    int print_mem_flag = 0;
    char *p;
! 
    /* save in case md file wants to emit args as a comment.  */
    save_argc = argc;
    save_argv = argv;
  
    p = argv[0] + strlen (argv[0]);
    while (p != argv[0] && p[-1] != '/') --p;
    progname = p;
  
  #ifdef RLIMIT_STACK
--- 1758,1778 ----
    char *filename = 0;
    int print_mem_flag = 0;
    char *p;
! #ifdef atarist
! /* turn this on if you are going to set the TOS 1.4 dont clear heap flag */
! /*  _malloczero(1); */ 	/* zero mallocs by default */
! #endif  
    /* save in case md file wants to emit args as a comment.  */
    save_argc = argc;
    save_argv = argv;
  
    p = argv[0] + strlen (argv[0]);
+ #ifndef atarist
    while (p != argv[0] && p[-1] != '/') --p;
+ #else
+   while (p != argv[0] && ( ((p[-1] != '/') || (p[-1] != '\\')) &&
+ 			  (p[-2] != ':') ) ) --p;
+ #endif
    progname = p;
  
  #ifdef RLIMIT_STACK
***************
*** 1758,1764 ****
--- 1789,1797 ----
  
    signal (SIGFPE, float_signal);
  
+ #ifndef atarist
    signal (SIGPIPE, pipe_closed);
+ #endif
  
    /* Initialize whether `char' is signed.  */
    flag_signed_char = DEFAULT_SIGNED_CHAR;
***************
*** 1788,1793 ****
--- 1821,1836 ----
  	else if (!strcmp (str, "dumpbase"))
  	  {
  	    dump_base_name = argv[++i];
+ #ifdef atarist
+ /* dump_base_name will typically be 'foo.c' here.  Need to truncate at the '.',
+    cause dots mean something here */
+ 	    {
+ 	      char * n = dump_base_name;
+ 	      for ( ; ((*n) && (*n != '.')) ; )
+ 		n++;
+ 	      *n = '\0';
+ 	    }
+ #endif
  	  }
  	else if (str[0] == 'd')
  	  {
***************
*** 1990,1995 ****
--- 2033,2039 ----
  
    compile_file (filename);
  
+ #if (!(defined(atarist) || defined(atariminix)))
  #ifndef USG
  #ifndef VMS
    if (print_mem_flag)
***************
*** 2005,2011 ****
      }
  #endif /* not VMS */
  #endif /* not USG */
! 
    if (errorcount)
      exit (FATAL_EXIT_CODE);
    if (sorrycount)
--- 2049,2055 ----
      }
  #endif /* not VMS */
  #endif /* not USG */
! #endif /* atarist or atariminix */
    if (errorcount)
      exit (FATAL_EXIT_CODE);
    if (sorrycount)
